Problem

A chained async memo reached through a synchronous derived memo drops its serialized value when it lives inside a nested <Loading> boundary. On the client the memo then re-runs its compute and orphans the server-streamed fragment:

Hydration completed with 1 unclaimed server-rendered node(s):
  <div _hk="…">item 1</div>

Minimal repro (the shape TanStack Start produces — route content nested in the root layout's boundary):

function Inner() {
  const a = createMemo(async () => { await sleep(10); return [1]; });
  const m = createMemo(() => a()[0]);            // sync — re-throws while a is pending
  const b = createMemo(() => fetchItems(m()));   // body throws synchronously on first pass
  return (
    <Loading fallback={<div>loading</div>}>
      <For each={b()}>{x => <div>{x}</div>}</For>
    </Loading>
  );
}

// BUG: only reproduces when nested in another boundary
<Loading fallback={<div>outer</div>}>
  <Inner />
</Loading>

The serialized stream contains a's [1] but not b's ["item 1"].

Root cause

b depends on a, so it resolves after a — and in the nested case that is after the surrounding boundary has already flushed and committed its serializeBuffer. b's late serialize call landed in a buffer that is never flushed again, so the value was silently dropped. (a survives because it resolves before the commit.) Single-boundary works only by timing luck.

Fix

Once a boundary has flushed, later serializations write through to the parent context instead of buffering into a buffer that will never flush again. Safe because buffer resets only happen during retry discovery, which is always before the first flush.

let flushed = false;
bufferedCtx.serialize = (id, value, deferStream) => {
  if (flushed) ctx.serialize(id, value, deferStream);
  else serializeBuffer.push([id, value, deferStream]);
};
function flushSerializeBuffer() {
  for (const args of serializeBuffer) ctx.serialize(args[0], args[1], args[2]);
  serializeBuffer = [];
  flushed = true;
}

Tests

Added to the existing describe("SSR Streaming — Chained Async") suite: single boundary, nested boundary, deeply nested boundaries, and renderToStringAsync nested. The three nested cases fail without the fix and pass with it; single passes either way. Full server (91), hydration (18), and client (298) suites pass.

🤖 Generated with Claude Code